package com.sync.platform.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 文件模式匹配工具类
 */
public class FilePatternUtil {

    private static final Logger logger = LoggerFactory.getLogger(FilePatternUtil.class);

    /**
     * 判断文件名是否匹配指定的模式
     * 
     * @param fileName 文件名
     * @param pattern 模式（支持*和?通配符）
     * @return 是否匹配
     */
    public static boolean matchPattern(String fileName, String pattern) {
        if (fileName == null || pattern == null) {
            return false;
        }
        
        // 直接相等的情况
        if (pattern.equals(fileName)) {
            return true;
        }
        
        // 如果模式中没有通配符，则需要完全匹配
        if (!pattern.contains("*") && !pattern.contains("?")) {
            return pattern.equals(fileName);
        }
        
        // 将通配符模式转换为正则表达式
        String regex = pattern
            .replace(".", "\\.")  // 转义点号
            .replace("*", ".*")   // *转换为正则的.*
            .replace("?", ".");   // ?转换为正则的单个字符.
        
        return fileName.matches(regex);
    }
    
    /**
     * 判断文件名是否匹配任一模式
     * 
     * @param fileName 文件名
     * @param patterns 模式数组（逗号分隔，支持*和?通配符）
     * @return 是否匹配任一模式
     */
    public static boolean matchAnyPattern(String fileName, String[] patterns) {
        if (fileName == null || patterns == null || patterns.length == 0) {
            return true; // 如果没有模式，则默认匹配所有
        }
        
        for (String pattern : patterns) {
            if (pattern == null || pattern.trim().isEmpty()) {
                continue;
            }
            
            if (matchPattern(fileName, pattern.trim())) {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * 解析文件过滤模式字符串
     * 
     * @param filePattern 过滤模式字符串（逗号分隔）
     * @return 模式数组，如果没有有效模式则返回null
     */
    public static String[] parsePatterns(String filePattern) {
        if (filePattern == null || filePattern.trim().isEmpty()) {
            return null;
        }
        
        String[] patterns = filePattern.split(",");
        boolean hasValidPattern = false;
        
        for (int i = 0; i < patterns.length; i++) {
            patterns[i] = patterns[i].trim();
            if (!patterns[i].isEmpty()) {
                hasValidPattern = true;
            }
        }
        
        return hasValidPattern ? patterns : null;
    }
    
    /**
     * 获取模式的描述
     * 
     * @param pattern 模式
     * @return 模式描述
     */
    public static String getPatternDescription(String pattern) {
        if (pattern == null || pattern.isEmpty()) {
            return "空模式";
        }
        
        if (pattern.contains("*") || pattern.contains("?")) {
            return pattern + " (通配符模式)";
        } else {
            return pattern + " (精确匹配)";
        }
    }
} 